home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet multimedia / Muzyka / Edytory sampli (probek dzwieku) / ZynAddSubFX_2.2.0 / Setup_ZynAddSubFX-2.2.0.exe / source code / Misc / Part.C < prev    next >
C/C++ Source or Header  |  2005-03-14  |  25KB  |  876 lines
  1. /*
  2.   ZynAddSubFX - a software synthesizer
  3.  
  4.   Part.C - Part implementation
  5.   Copyright (C) 2002-2005 Nasca Octavian Paul
  6.   Author: Nasca Octavian Paul
  7.  
  8.   This program is free software; you can redistribute it and/or modify
  9.   it under the terms of version 2 of the GNU General Public License 
  10.   as published by the Free Software Foundation.
  11.  
  12.   This program is distributed in the hope that it will be useful,
  13.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.   GNU General Public License (version 2) for more details.
  16.  
  17.   You should have received a copy of the GNU General Public License (version 2)
  18.   along with this program; if not, write to the Free Software Foundation,
  19.   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20.  
  21. */
  22.  
  23. #include "Part.h"
  24. #include "Microtonal.h"
  25. #include <stdlib.h>
  26. #include <stdio.h>
  27. #include <string.h>
  28.  
  29. Part::Part(Microtonal *microtonal_,FFTwrapper *fft_, pthread_mutex_t *mutex_){
  30.     microtonal=microtonal_;    
  31.     fft=fft_;
  32.     mutex=mutex_;
  33.     partoutl=new REALTYPE [SOUND_BUFFER_SIZE];
  34.     partoutr=new REALTYPE [SOUND_BUFFER_SIZE];
  35.     tmpoutl=new REALTYPE [SOUND_BUFFER_SIZE];
  36.     tmpoutr=new REALTYPE [SOUND_BUFFER_SIZE];
  37.     
  38.     for (int n=0;n<NUM_KIT_ITEMS;n++){
  39.     kit[n].Pname=new unsigned char [PART_MAX_NAME_LEN];
  40.     kit[n].adpars=NULL;kit[n].subpars=NULL;kit[n].padpars=NULL;
  41.     };
  42.  
  43.     kit[0].adpars=new ADnoteParameters(fft);
  44.     kit[0].subpars=new SUBnoteParameters();
  45.     kit[0].padpars=new PADnoteParameters(fft,mutex);
  46. //    ADPartParameters=kit[0].adpars;
  47. //    SUBPartParameters=kit[0].subpars;
  48.  
  49.     //Part's Insertion Effects init
  50.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++) 
  51.         partefx[nefx]=new EffectMgr(1,mutex);
  52.  
  53.     for (int n=0;n<NUM_PART_EFX+1;n++) {
  54.     partfxinputl[n]=new REALTYPE [SOUND_BUFFER_SIZE];
  55.     partfxinputr[n]=new REALTYPE [SOUND_BUFFER_SIZE];
  56.     Pefxbypass[n]=false;
  57.     };
  58.  
  59.     killallnotes=0;
  60.     oldfreq=-1.0;
  61.  
  62.     int i,j;
  63.     for (i=0;i<POLIPHONY;i++){
  64.       partnote[i].status=KEY_OFF;
  65.       partnote[i].note=-1;
  66.       partnote[i].itemsplaying=0;
  67.       for (j=0;j<NUM_KIT_ITEMS;j++){
  68.         partnote[i].kititem[j].adnote=NULL;
  69.         partnote[i].kititem[j].subnote=NULL;
  70.         partnote[i].kititem[j].padnote=NULL;
  71.       };
  72.       partnote[i].time=0;
  73.     };
  74.     cleanup();    
  75.  
  76.     Pname=new unsigned char [PART_MAX_NAME_LEN];
  77.     
  78.     oldvolumel=oldvolumer=0.5;
  79.     lastnote=-1;
  80.     
  81.     
  82.     defaults();
  83. };
  84.  
  85. void Part::defaults(){
  86.     Penabled=0;
  87.     Pminkey=0;
  88.     Pmaxkey=127;
  89.     Pnoteon=1;
  90.     Ppolymode=1;
  91.     setPvolume(96);
  92.     Pkeyshift=64;
  93.     Prcvchn=0;
  94.     setPpanning(64);
  95.     Pvelsns=64;
  96.     Pveloffs=64;
  97.     Pkeylimit=15;
  98.     defaultsinstrument();
  99.     ctl.defaults();
  100. };
  101.  
  102. void Part::defaultsinstrument(){
  103.     ZERO(Pname,PART_MAX_NAME_LEN);
  104.  
  105.     info.Ptype=0;
  106.     ZERO(info.Pauthor,MAX_INFO_TEXT_SIZE+1);
  107.     ZERO(info.Pcomments,MAX_INFO_TEXT_SIZE+1);
  108.  
  109.     Pkitmode=0;
  110.     Pdrummode=0;
  111.  
  112.     for (int n=0;n<NUM_KIT_ITEMS;n++){
  113.     kit[n].Penabled=0;kit[n].Pmuted=0;
  114.     kit[n].Pminkey=0;kit[n].Pmaxkey=127;
  115.     kit[n].Padenabled=0;kit[n].Psubenabled=0;kit[n].Ppadenabled=0;
  116.     ZERO(kit[n].Pname,PART_MAX_NAME_LEN);
  117.     kit[n].Psendtoparteffect=0;
  118.     if (n!=0) setkititemstatus(n,0);
  119.     };
  120.     kit[0].Penabled=1;
  121.     kit[0].Padenabled=1;
  122.     kit[0].adpars->defaults();
  123.     kit[0].subpars->defaults();
  124.     kit[0].padpars->defaults();
  125.     
  126.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++) {
  127.         partefx[nefx]->defaults();
  128.     Pefxroute[nefx]=0;//route to next effect
  129.     };
  130.  
  131. };
  132.  
  133.  
  134.  
  135. /*
  136.  * Cleanup the part
  137.  */
  138. void Part::cleanup(){
  139.     for (int k=0;k<POLIPHONY;k++) KillNotePos(k);
  140.     for (int i=0;i<SOUND_BUFFER_SIZE;i++){
  141.     partoutl[i]=denormalkillbuf[i];
  142.     partoutr[i]=denormalkillbuf[i];
  143.     tmpoutl[i]=0.0;
  144.     tmpoutr[i]=0.0;
  145.     };
  146.     ctl.resetall();
  147.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++) partefx[nefx]->cleanup();
  148.     for (int n=0;n<NUM_PART_EFX+1;n++) {
  149.     for (int i=0;i<SOUND_BUFFER_SIZE;i++){
  150.         partfxinputl[n][i]=denormalkillbuf[i];
  151.         partfxinputr[n][i]=denormalkillbuf[i];
  152.     };
  153.     };
  154. };
  155.  
  156. Part::~Part(){
  157.     cleanup();
  158.     for (int n=0;n<NUM_KIT_ITEMS;n++){
  159.     if (kit[n].adpars!=NULL) delete (kit[n].adpars);
  160.     if (kit[n].subpars!=NULL) delete (kit[n].subpars);
  161.     if (kit[n].padpars!=NULL) delete (kit[n].padpars);
  162.         kit[n].adpars=NULL;kit[n].subpars=NULL;kit[n].padpars=NULL;
  163.     delete(kit[n].Pname);
  164.     };
  165.  
  166.     delete (Pname);
  167.     delete (partoutl);
  168.     delete (partoutr);
  169.     delete (tmpoutl);
  170.     delete (tmpoutr);
  171.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++) 
  172.     delete (partefx[nefx]);
  173.     for (int n=0;n<NUM_PART_EFX+1;n++) {
  174.     delete (partfxinputl[n]);
  175.     delete (partfxinputr[n]);
  176.     };
  177. };
  178.  
  179. /*
  180.  * Note On Messages
  181.  */
  182. void Part::NoteOn(unsigned char note,unsigned char velocity,int masterkeyshift){
  183.     int i,pos;    
  184.     
  185.     lastnote=note;    
  186.     if ((note<Pminkey)||(note>Pmaxkey)) return;
  187.     
  188.     pos=-1;
  189.     for (i=0;i<POLIPHONY;i++){
  190.         if (partnote[i].status==KEY_OFF){
  191.             pos=i;
  192.         break;
  193.     };
  194.     };
  195.  
  196.     if (Ppolymode==0){//if the mode is 'mono' turn off all other notes
  197.     for (i=0;i<POLIPHONY;i++)
  198.         if (partnote[i].status==KEY_PLAYING) NoteOff(partnote[i].note);
  199.     RelaseSustainedKeys();    
  200.     };
  201.     
  202.     if (pos==-1){
  203.         //test
  204.     fprintf(stderr,"%s","NOTES TOO MANY (> POLIPHONY) - (Part.C::NoteOn(..))\n");
  205.     } else {
  206.     if (Pnoteon!=0){
  207.         //start the note
  208.             partnote[pos].status=KEY_PLAYING;
  209.             partnote[pos].note=note;
  210.  
  211.         //this computes the velocity sensing of the part 
  212.         REALTYPE vel=VelF(velocity/127.0,Pvelsns);
  213.  
  214.         //compute the velocity offset
  215.         vel+=(Pveloffs-64.0)/64.0;
  216.         if (vel<0.0) vel=0.0; else if (vel>1.0) vel=1.0;
  217.  
  218.         //compute the keyshift            
  219.         int partkeyshift=(int)Pkeyshift-64;
  220.         int keyshift=masterkeyshift+partkeyshift;
  221.  
  222.         //initialise note frequency
  223.         REALTYPE notebasefreq;
  224.         if (Pdrummode==0){
  225.         notebasefreq=microtonal->getnotefreq(note,keyshift);
  226.         if (notebasefreq<0.0) return;//the key is no mapped
  227.         } else {
  228.         notebasefreq=440.0*pow(2.0,(note-69.0)/12.0);
  229.         };
  230.         
  231.         //Portamento
  232.         if (oldfreq<1.0) oldfreq=notebasefreq;//this is only the first note is played
  233.         
  234.         int portamento=ctl.initportamento(oldfreq,notebasefreq);
  235.         
  236.         if (portamento!=0) ctl.portamento.noteusing=pos;
  237.         oldfreq=notebasefreq;
  238.         
  239.         partnote[pos].itemsplaying=0;
  240.         if (Pkitmode==0){//init the notes for the "normal mode"
  241.         partnote[pos].kititem[0].sendtoparteffect=0;
  242.             if (kit[0].Padenabled!=0) partnote[pos].kititem[0].adnote=new ADnote(kit[0].adpars,&ctl,notebasefreq,vel,portamento,note);
  243.             if (kit[0].Psubenabled!=0) partnote[pos].kititem[0].subnote=new SUBnote(kit[0].subpars,&ctl,notebasefreq,vel,portamento,note);
  244.             if (kit[0].Ppadenabled!=0) partnote[pos].kititem[0].padnote=new PADnote(kit[0].padpars,&ctl,notebasefreq,vel,portamento,note);
  245.         if ((kit[0].Padenabled!=0)||(kit[0].Psubenabled!=0)||(kit[0].Ppadenabled!=0)) partnote[pos].itemsplaying++;
  246.  
  247.         } else {//init the notes for the "kit mode"
  248.         for (int item=0;item<NUM_KIT_ITEMS;item++){
  249.             if (kit[item].Pmuted!=0) continue;
  250.             if ((note<kit[item].Pminkey)||(note>kit[item].Pmaxkey)) continue;
  251.  
  252.             int ci=partnote[pos].itemsplaying;//ci=current item
  253.  
  254.             partnote[pos].kititem[ci].sendtoparteffect=( kit[item].Psendtoparteffect<NUM_PART_EFX ?
  255.                 kit[item].Psendtoparteffect: NUM_PART_EFX);//if this parameter is 127 for "unprocessed"
  256.  
  257.                 if ((kit[item].adpars!=NULL)&&(kit[item].Padenabled)!=0) 
  258.               partnote[pos].kititem[ci].adnote=new ADnote(kit[item].adpars,&ctl,notebasefreq,vel,portamento,note);
  259.  
  260.                 if ((kit[item].subpars!=NULL)&&(kit[item].Psubenabled)!=0) 
  261.               partnote[pos].kititem[ci].subnote=new SUBnote(kit[item].subpars,&ctl,notebasefreq,vel,portamento,note);
  262.  
  263.                 if ((kit[item].padpars!=NULL)&&(kit[item].Ppadenabled)!=0) 
  264.               partnote[pos].kititem[ci].padnote=new PADnote(kit[item].padpars,&ctl,notebasefreq,vel,portamento,note);
  265.  
  266.             if ((kit[item].adpars!=NULL)|| (kit[item].subpars!=NULL)) {
  267.             partnote[pos].itemsplaying++;
  268.             if ( ((kit[item].Padenabled!=0)||(kit[item].Psubenabled!=0)||(kit[item].Ppadenabled!=0))
  269.                && (Pkitmode==2) ) break;
  270.             };
  271.         };
  272.         };
  273.     };
  274.     };
  275.     
  276.     //this only relase the keys if there is maximum number of keys allowed
  277.     setkeylimit(Pkeylimit);
  278. };
  279.  
  280. /*
  281.  * Note Off Messages
  282.  */
  283. void Part::NoteOff(unsigned char note){//relase the key
  284.     int i;    
  285.     for (i=POLIPHONY-1;i>=0;i--){ //first note in, is first out if there are same note multiple times
  286.     if ((partnote[i].status==KEY_PLAYING)&&(partnote[i].note==note)) {
  287.         if (ctl.sustain.sustain==0){ //the sustain pedal is not pushed
  288.         RelaseNotePos(i);
  289.         break;
  290.         } else {//the sustain pedal is pushed
  291.         partnote[i].status=KEY_RELASED_AND_SUSTAINED;
  292.         };
  293.     };
  294.     };
  295. };
  296.  
  297. /*
  298.  * Controllers
  299.  */
  300. void Part::SetController(unsigned int type,int par){
  301.     switch (type){
  302.     case C_pitchwheel:ctl.setpitchwheel(par);
  303.               break;
  304.     case C_expression:ctl.setexpression(par);
  305.               setPvolume(Pvolume);//update the volume
  306.               break;
  307.     case C_portamento:ctl.setportamento(par);
  308.               break;
  309.     case C_panning:ctl.setpanning(par);
  310.               setPpanning(Ppanning);//update the panning
  311.               break;
  312.     case C_filtercutoff:ctl.setfiltercutoff(par);
  313.               break;
  314.     case C_filterq:ctl.setfilterq(par);
  315.               break;
  316.     case C_bandwidth:ctl.setbandwidth(par);
  317.               break;
  318.     case C_modwheel:ctl.setmodwheel(par);
  319.               break;
  320.     case C_fmamp:ctl.setfmamp(par);
  321.               break;
  322.     case C_volume:ctl.setvolume(par);
  323.                  if (ctl.volume.receive!=0) volume=ctl.volume.volume;
  324.                 else setPvolume(Pvolume);
  325.               break;
  326.     case C_sustain:ctl.setsustain(par);
  327.               if (ctl.sustain.sustain==0) RelaseSustainedKeys();
  328.               break;
  329.     case C_allsoundsoff:AllNotesOff();//Panic
  330.               break;
  331.     case C_resetallcontrollers:
  332.               ctl.resetall();
  333.               RelaseSustainedKeys();
  334.                      if (ctl.volume.receive!=0) volume=ctl.volume.volume;
  335.                     else setPvolume(Pvolume);
  336.               setPvolume(Pvolume);//update the volume
  337.               setPpanning(Ppanning);//update the panning
  338.               
  339.                   for (int item=0;item<NUM_KIT_ITEMS;item++){
  340.                 if (kit[item].adpars==NULL) continue;
  341.                 kit[item].adpars->GlobalPar.Reson->
  342.                    sendcontroller(C_resonance_center,1.0);
  343.                 
  344.                 kit[item].adpars->GlobalPar.Reson->
  345.                    sendcontroller(C_resonance_bandwidth,1.0);
  346.               };                 
  347.               //more update to add here if I add controllers
  348.               break;
  349.     case C_allnotesoff:RelaseAllKeys();
  350.               break;
  351.     case C_resonance_center:
  352.             ctl.setresonancecenter(par);
  353.                 for (int item=0;item<NUM_KIT_ITEMS;item++){
  354.                  if (kit[item].adpars==NULL) continue;
  355.                   kit[item].adpars->GlobalPar.Reson->
  356.                    sendcontroller(C_resonance_center,ctl.resonancecenter.relcenter);
  357.                 };
  358.               break;
  359.     case C_resonance_bandwidth:
  360.             ctl.setresonancebw(par);
  361.             kit[0].adpars->GlobalPar.Reson->
  362.                 sendcontroller(C_resonance_bandwidth,ctl.resonancebandwidth.relbw);
  363.               break;
  364.     };
  365. };
  366. /*
  367.  * Relase the sustained keys
  368.  */
  369.  
  370. void Part::RelaseSustainedKeys(){
  371.     for (int i=0;i<POLIPHONY;i++)
  372.     if (partnote[i].status==KEY_RELASED_AND_SUSTAINED) RelaseNotePos(i);
  373. };
  374.  
  375. /*
  376.  * Relase all keys
  377.  */
  378.  
  379. void Part::RelaseAllKeys(){
  380.     for (int i=0;i<POLIPHONY;i++){
  381.     if ((partnote[i].status!=KEY_RELASED)&&
  382.         (partnote[i].status!=KEY_OFF)) //thanks to Frank Neumann
  383.         RelaseNotePos(i);
  384.     };
  385. };
  386.  
  387. /*
  388.  * Release note at position
  389.  */
  390. void Part::RelaseNotePos(int pos){
  391.  
  392.     for (int j=0;j<NUM_KIT_ITEMS;j++){
  393.  
  394.      if (partnote[pos].kititem[j].adnote!=NULL) 
  395.         if (partnote[pos].kititem[j].adnote) 
  396.       partnote[pos].kititem[j].adnote->relasekey();
  397.  
  398.      if (partnote[pos].kititem[j].subnote!=NULL) 
  399.         if (partnote[pos].kititem[j].subnote!=NULL) 
  400.       partnote[pos].kititem[j].subnote->relasekey();        
  401.  
  402.      if (partnote[pos].kititem[j].padnote!=NULL) 
  403.         if (partnote[pos].kititem[j].padnote) 
  404.       partnote[pos].kititem[j].padnote->relasekey();
  405.     };
  406.     partnote[pos].status=KEY_RELASED;
  407. }; 
  408.  
  409.  
  410. /*
  411.  * Kill note at position
  412.  */
  413. void Part::KillNotePos(int pos){
  414.     partnote[pos].status=KEY_OFF;
  415.     partnote[pos].note=-1;
  416.     partnote[pos].time=0;
  417.     partnote[pos].itemsplaying=0;
  418.  
  419.     for (int j=0;j<NUM_KIT_ITEMS;j++){
  420.      if (partnote[pos].kititem[j].adnote!=NULL) {
  421.         delete(partnote[pos].kititem[j].adnote);
  422.         partnote[pos].kititem[j].adnote=NULL;
  423.      };
  424.      if (partnote[pos].kititem[j].subnote!=NULL) {
  425.         delete(partnote[pos].kititem[j].subnote);
  426.         partnote[pos].kititem[j].subnote=NULL;
  427.      };
  428.      if (partnote[pos].kititem[j].padnote!=NULL) {
  429.         delete(partnote[pos].kititem[j].padnote);
  430.         partnote[pos].kititem[j].padnote=NULL;
  431.      };
  432.     };
  433.     if (pos==ctl.portamento.noteusing) {
  434.     ctl.portamento.noteusing=-1;
  435.     ctl.portamento.used=0;
  436.     };
  437. };
  438.  
  439.  
  440. /*
  441.  * Set Part's key limit
  442.  */
  443. void Part::setkeylimit(unsigned char Pkeylimit){
  444.     this->Pkeylimit=Pkeylimit;
  445.     int keylimit=Pkeylimit;
  446.     if (keylimit==0) keylimit=POLIPHONY-5;
  447.  
  448.     //release old keys if the number of notes>keylimit
  449.     if (Ppolymode!=0){
  450.     int notecount=0;
  451.     for (int i=0;i<POLIPHONY;i++){
  452.         if ((partnote[i].status==KEY_PLAYING)||(partnote[i].status==KEY_RELASED_AND_SUSTAINED))
  453.             notecount++;
  454.     };
  455.     int oldestnotepos=-1,maxtime=0;
  456.     if (notecount>keylimit){//find out the oldest note
  457.         for (int i=0;i<POLIPHONY;i++){
  458.         if ( ((partnote[i].status==KEY_PLAYING)||(partnote[i].status==KEY_RELASED_AND_SUSTAINED))
  459.            && (partnote[i].time>maxtime)){
  460.               maxtime=partnote[i].time;
  461.               oldestnotepos=i;
  462.             };
  463.         };
  464.     };
  465.     if (oldestnotepos!=-1) RelaseNotePos(oldestnotepos);
  466.     };
  467. };
  468.  
  469.  
  470. /*
  471.  * Prepare all notes to be turned off
  472.  */
  473. void Part::AllNotesOff(){
  474.    killallnotes=1;    
  475. };
  476.  
  477.  
  478. /*
  479.  * Compute Part samples and store them in the partoutl[] and partoutr[]
  480.  */
  481. void Part::ComputePartSmps(){
  482.     int i,k;
  483.     int noteplay;//0 if there is nothing activated
  484.     for (int nefx=0;nefx<NUM_PART_EFX+1;nefx++){
  485.     for (i=0;i<SOUND_BUFFER_SIZE;i++){
  486.         partfxinputl[nefx][i]=0.0;
  487.         partfxinputr[nefx][i]=0.0;
  488.     };
  489.     };
  490.     
  491.     for (k=0;k<POLIPHONY;k++){
  492.         if (partnote[k].status==KEY_OFF) continue;
  493.     noteplay=0;    
  494.     partnote[k].time++;
  495.     //get the sampledata of the note and kill it if it's finished
  496.  
  497.         for (int item=0;item<partnote[k].itemsplaying;item++){
  498.  
  499.         int sendcurrenttofx=partnote[k].kititem[item].sendtoparteffect;
  500.         
  501.         ADnote *adnote=partnote[k].kititem[item].adnote;
  502.         SUBnote *subnote=partnote[k].kititem[item].subnote;
  503.         PADnote *padnote=partnote[k].kititem[item].padnote;
  504.        //get from the ADnote
  505.             if (adnote!=NULL) {
  506.             noteplay++;
  507.         if (adnote->ready!=0) adnote->noteout(&tmpoutl[0],&tmpoutr[0]);
  508.                     else for (i=0;i<SOUND_BUFFER_SIZE;i++){tmpoutl[i]=0.0;tmpoutr[i]=0.0;};
  509.         if (adnote->finished()!=0){
  510.             delete (adnote);
  511.             partnote[k].kititem[item].adnote=NULL;
  512.         };
  513.         for (i=0;i<SOUND_BUFFER_SIZE;i++){//add the ADnote to part(mix)
  514.             partfxinputl[sendcurrenttofx][i]+=tmpoutl[i];
  515.             partfxinputr[sendcurrenttofx][i]+=tmpoutr[i];
  516.         };
  517.         };
  518.         //get from the SUBnote
  519.             if (subnote!=NULL) {
  520.             noteplay++;
  521.         if (subnote->ready!=0) subnote->noteout(&tmpoutl[0],&tmpoutr[0]);
  522.                     else for (i=0;i<SOUND_BUFFER_SIZE;i++){tmpoutl[i]=0.0;tmpoutr[i]=0.0;};
  523.  
  524.             for (i=0;i<SOUND_BUFFER_SIZE;i++){//add the SUBnote to part(mix)
  525.             partfxinputl[sendcurrenttofx][i]+=tmpoutl[i];
  526.             partfxinputr[sendcurrenttofx][i]+=tmpoutr[i];
  527.         };
  528.         if (subnote->finished()!=0){
  529.             delete (subnote);
  530.             partnote[k].kititem[item].subnote=NULL;
  531.         };
  532.         };    
  533.        //get from the PADnote
  534.             if (padnote!=NULL) {
  535.             noteplay++;
  536.         if (padnote->ready!=0) padnote->noteout(&tmpoutl[0],&tmpoutr[0]);
  537.                     else for (i=0;i<SOUND_BUFFER_SIZE;i++){tmpoutl[i]=0.0;tmpoutr[i]=0.0;};
  538.         if (padnote->finished()!=0){
  539.             delete (padnote);
  540.             partnote[k].kititem[item].padnote=NULL;
  541.         };
  542.         for (i=0;i<SOUND_BUFFER_SIZE;i++){//add the PADnote to part(mix)
  543.             partfxinputl[sendcurrenttofx][i]+=tmpoutl[i];
  544.             partfxinputr[sendcurrenttofx][i]+=tmpoutr[i];
  545.         };
  546.         };
  547.  
  548.     };
  549.     //Kill note if there is no synth on that note
  550.     if (noteplay==0) KillNotePos(k);
  551.     };
  552.  
  553.  
  554.     //Apply part's effects and mix them
  555.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++) {
  556.         if (!Pefxbypass[nefx]) {
  557.         partefx[nefx]->out(partfxinputl[nefx],partfxinputr[nefx]);
  558.         if (Pefxroute[nefx]==2){
  559.         for (i=0;i<SOUND_BUFFER_SIZE;i++){
  560.             partfxinputl[nefx+1][i]+=partefx[nefx]->efxoutl[i];
  561.             partfxinputr[nefx+1][i]+=partefx[nefx]->efxoutr[i];
  562.         };
  563.         };
  564.     };
  565.     int routeto=((Pefxroute[nefx]==0) ? nefx+1 : NUM_PART_EFX);
  566.     for (i=0;i<SOUND_BUFFER_SIZE;i++){
  567.         partfxinputl[routeto][i]+=partfxinputl[nefx][i];
  568.         partfxinputr[routeto][i]+=partfxinputr[nefx][i];
  569.     };
  570.     
  571.     };
  572.     for (i=0;i<SOUND_BUFFER_SIZE;i++){
  573.         partoutl[i]=partfxinputl[NUM_PART_EFX][i];
  574.     partoutr[i]=partfxinputr[NUM_PART_EFX][i];
  575.     };
  576.  
  577.     //Kill All Notes if killallnotes!=0
  578.     if (killallnotes!=0) {
  579.     for (i=0;i<SOUND_BUFFER_SIZE;i++) {
  580.         REALTYPE tmp=(SOUND_BUFFER_SIZE-i)/(REALTYPE) SOUND_BUFFER_SIZE;
  581.         partoutl[i]*=tmp;
  582.         partoutr[i]*=tmp;
  583.         tmpoutl[i]=0.0;
  584.         tmpoutr[i]=0.0;
  585.     };
  586.     for (int k=0;k<POLIPHONY;k++) KillNotePos(k);
  587.     killallnotes=0;
  588.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++) {
  589.             partefx[nefx]->cleanup();
  590.     };
  591.     };
  592.     ctl.updateportamento();
  593. };
  594.  
  595. /*
  596.  * Parameter control
  597.  */
  598. void Part::setPvolume(char Pvolume_){
  599.     Pvolume=Pvolume_;
  600.     volume=dB2rap((Pvolume-96.0)/96.0*40.0)*ctl.expression.relvolume;
  601. };
  602.  
  603. void Part::setPpanning(char Ppanning_){
  604.     Ppanning=Ppanning_;
  605.     panning=Ppanning/127.0+ctl.panning.pan;
  606.     if (panning<0.0) panning=0.0;else if (panning>1.0) panning=1.0;
  607.  
  608. };
  609.  
  610. /*
  611.  * Enable or disable a kit item
  612.  */
  613. void Part::setkititemstatus(int kititem,int Penabled_){
  614.     if ((kititem==0)&&(kititem>=NUM_KIT_ITEMS)) return;//nonexistent kit item and the first kit item is always enabled
  615.     kit[kititem].Penabled=Penabled_;
  616.     
  617.     bool resetallnotes=false;
  618.     if (Penabled_==0){
  619.     if (kit[kititem].adpars!=NULL) delete (kit[kititem].adpars);
  620.     if (kit[kititem].subpars!=NULL) delete (kit[kititem].subpars);
  621.     if (kit[kititem].padpars!=NULL) {
  622.         delete (kit[kititem].padpars);
  623.         resetallnotes=true;
  624.     };
  625.     kit[kititem].adpars=NULL;kit[kititem].subpars=NULL;kit[kititem].padpars=NULL;
  626.     kit[kititem].Pname[0]='\0';
  627.     } else {
  628.     if (kit[kititem].adpars==NULL) kit[kititem].adpars=new ADnoteParameters(fft);
  629.     if (kit[kititem].subpars==NULL) kit[kititem].subpars=new SUBnoteParameters();
  630.     if (kit[kititem].padpars==NULL) kit[kititem].padpars=new PADnoteParameters(fft,mutex);
  631.     };
  632.     
  633.     if (resetallnotes)     for (int k=0;k<POLIPHONY;k++) KillNotePos(k);
  634. };
  635.  
  636.  
  637.  
  638. void Part::add2XMLinstrument(XMLwrapper *xml){
  639.     xml->beginbranch("INFO");
  640.     xml->addparstr("name",(char *)Pname);
  641.     xml->addparstr("author",(char *)info.Pauthor);
  642.     xml->addparstr("comments",(char *)info.Pcomments);
  643.     xml->addpar("type",info.Ptype);
  644.     xml->endbranch();
  645.     
  646.     
  647.     xml->beginbranch("INSTRUMENT_KIT");
  648.     xml->addpar("kit_mode",Pkitmode);
  649.     xml->addparbool("drum_mode",Pdrummode);
  650.  
  651.     for (int i=0;i<NUM_KIT_ITEMS;i++){
  652.         xml->beginbranch("INSTRUMENT_KIT_ITEM",i);
  653.         xml->addparbool("enabled",kit[i].Penabled);
  654.         if (kit[i].Penabled!=0) {
  655.             xml->addparstr("name",(char *)kit[i].Pname);
  656.  
  657.             xml->addparbool("muted",kit[i].Pmuted);
  658.             xml->addpar("min_key",kit[i].Pminkey);
  659.             xml->addpar("max_key",kit[i].Pmaxkey);
  660.         
  661.             xml->addpar("send_to_instrument_effect",kit[i].Psendtoparteffect);
  662.  
  663.             xml->addparbool("add_enabled",kit[i].Padenabled);
  664.             if ((kit[i].Padenabled!=0)&&(kit[i].adpars!=NULL)){
  665.             xml->beginbranch("ADD_SYNTH_PARAMETERS");
  666.                 kit[i].adpars->add2XML(xml);
  667.             xml->endbranch();
  668.             };
  669.  
  670.             xml->addparbool("sub_enabled",kit[i].Psubenabled);
  671.             if ((kit[i].Psubenabled!=0)&&(kit[i].subpars!=NULL)){
  672.             xml->beginbranch("SUB_SYNTH_PARAMETERS");
  673.             kit[i].subpars->add2XML(xml);
  674.             xml->endbranch();
  675.             };
  676.  
  677.             xml->addparbool("pad_enabled",kit[i].Ppadenabled);
  678.             if ((kit[i].Ppadenabled!=0)&&(kit[i].padpars!=NULL)){
  679.             xml->beginbranch("PAD_SYNTH_PARAMETERS");
  680.                 kit[i].padpars->add2XML(xml);
  681.             xml->endbranch();
  682.             };
  683.         
  684.         };
  685.         xml->endbranch();
  686.     };
  687.     xml->endbranch();
  688.     
  689.     xml->beginbranch("INSTRUMENT_EFFECTS");    
  690.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++){
  691.     xml->beginbranch("INSTRUMENT_EFFECT",nefx);
  692.         xml->beginbranch("EFFECT");
  693.         partefx[nefx]->add2XML(xml);
  694.         xml->endbranch();
  695.  
  696.         xml->addpar("route",Pefxroute[nefx]);
  697.         partefx[nefx]->setdryonly(Pefxroute[nefx]==2);
  698.         xml->addparbool("bypass",Pefxbypass[nefx]);
  699.     xml->endbranch();
  700.     };
  701.     xml->endbranch();
  702. };
  703.  
  704.  
  705. void Part::add2XML(XMLwrapper *xml){
  706.     //parameters
  707.     xml->addparbool("enabled",Penabled);
  708.     if ((Penabled==0)&&(xml->minimal)) return;
  709.  
  710.     xml->addpar("volume",Pvolume);
  711.     xml->addpar("panning",Ppanning);
  712.  
  713.     xml->addpar("min_key",Pminkey);
  714.     xml->addpar("max_key",Pmaxkey);
  715.     xml->addpar("key_shift",Pkeyshift);
  716.     xml->addpar("rcv_chn",Prcvchn);
  717.  
  718.     xml->addpar("velocity_sensing",Pvelsns);
  719.     xml->addpar("velocity_offset",Pveloffs);
  720.  
  721.     xml->addparbool("note_on",Pnoteon);
  722.     xml->addparbool("poly_mode",Ppolymode);
  723.     xml->addpar("key_limit",Pkeylimit);
  724.  
  725.     xml->beginbranch("INSTRUMENT");
  726.     add2XMLinstrument(xml);
  727.     xml->endbranch();
  728.     
  729.     xml->beginbranch("CONTROLLER");
  730.     ctl.add2XML(xml);
  731.     xml->endbranch();
  732. };
  733.  
  734. int Part::saveXML(char *filename){
  735.     XMLwrapper *xml;
  736.     xml=new XMLwrapper();
  737.  
  738.     xml->beginbranch("INSTRUMENT");
  739.     add2XMLinstrument(xml);
  740.     xml->endbranch();
  741.  
  742.     int result=xml->saveXMLfile(filename);
  743.     delete (xml);
  744.     return(result);
  745. };
  746.  
  747. int Part::loadXMLinstrument(const char *filename){
  748.     XMLwrapper *xml=new XMLwrapper();
  749.     if (xml->loadXMLfile(filename)<0) {
  750.     delete(xml);
  751.     return(-1);
  752.     };
  753.     
  754.     if (xml->enterbranch("INSTRUMENT")==0) return(-10);
  755.     getfromXMLinstrument(xml);
  756.     xml->exitbranch();
  757.     
  758.     delete(xml);
  759.     return(0);
  760. };
  761.  
  762.  
  763. void Part::applyparameters(){
  764.     for (int n=0;n<NUM_KIT_ITEMS;n++){
  765.     if ((kit[n].padpars!=NULL)&&(kit[n].Ppadenabled!=0)) kit[n].padpars->applyparameters(true);
  766.     };
  767. };
  768.  
  769. void Part::getfromXMLinstrument(XMLwrapper *xml){
  770.     if (xml->enterbranch("INFO")){
  771.     xml->getparstr("name",(char *)Pname,PART_MAX_NAME_LEN);
  772.     xml->getparstr("author",(char *)info.Pauthor,MAX_INFO_TEXT_SIZE);
  773.     xml->getparstr("comments",(char *)info.Pcomments,MAX_INFO_TEXT_SIZE);
  774.     info.Ptype=xml->getpar("type",info.Ptype,0,16);
  775.     
  776.     xml->exitbranch();
  777.     };
  778.  
  779.     if (xml->enterbranch("INSTRUMENT_KIT")){
  780.     Pkitmode=xml->getpar127("kit_mode",Pkitmode);
  781.     Pdrummode=xml->getparbool("drum_mode",Pdrummode);
  782.  
  783.     setkititemstatus(0,0);
  784.     for (int i=0;i<NUM_KIT_ITEMS;i++){
  785.         if (xml->enterbranch("INSTRUMENT_KIT_ITEM",i)==0) continue;
  786.         setkititemstatus(i,xml->getparbool("enabled",kit[i].Penabled));
  787.         if (kit[i].Penabled==0) {
  788.             xml->exitbranch();
  789.             continue;
  790.         };
  791.         
  792.         xml->getparstr("name",(char *)kit[i].Pname,PART_MAX_NAME_LEN);
  793.  
  794.         kit[i].Pmuted=xml->getparbool("muted",kit[i].Pmuted);
  795.         kit[i].Pminkey=xml->getpar127("min_key",kit[i].Pminkey);
  796.         kit[i].Pmaxkey=xml->getpar127("max_key",kit[i].Pmaxkey);
  797.         
  798.         kit[i].Psendtoparteffect=xml->getpar127("send_to_instrument_effect",kit[i].Psendtoparteffect);
  799.  
  800.         kit[i].Padenabled=xml->getparbool("add_enabled",kit[i].Padenabled);
  801.             if (xml->enterbranch("ADD_SYNTH_PARAMETERS")){
  802.             kit[i].adpars->getfromXML(xml);
  803.             xml->exitbranch();
  804.         };
  805.  
  806.         kit[i].Psubenabled=xml->getparbool("sub_enabled",kit[i].Psubenabled);
  807.         if (xml->enterbranch("SUB_SYNTH_PARAMETERS")){
  808.             kit[i].subpars->getfromXML(xml);
  809.             xml->exitbranch();
  810.         };
  811.  
  812.         kit[i].Ppadenabled=xml->getparbool("pad_enabled",kit[i].Ppadenabled);
  813.             if (xml->enterbranch("PAD_SYNTH_PARAMETERS")){
  814.             kit[i].padpars->getfromXML(xml);
  815.             xml->exitbranch();
  816.         };
  817.  
  818.         xml->exitbranch();
  819.     };
  820.         
  821.     xml->exitbranch();
  822.     };
  823.  
  824.     
  825.     if (xml->enterbranch("INSTRUMENT_EFFECTS")){
  826.     for (int nefx=0;nefx<NUM_PART_EFX;nefx++){
  827.         if (xml->enterbranch("INSTRUMENT_EFFECT",nefx)==0) continue;
  828.         if (xml->enterbranch("EFFECT")){
  829.             partefx[nefx]->getfromXML(xml);
  830.             xml->exitbranch();
  831.         };
  832.  
  833.         Pefxroute[nefx]=xml->getpar("route",Pefxroute[nefx],0,NUM_PART_EFX);
  834.         partefx[nefx]->setdryonly(Pefxroute[nefx]==2);
  835.         Pefxbypass[nefx]=xml->getparbool("bypass",Pefxbypass[nefx]);
  836.         xml->exitbranch();
  837.     };
  838.     xml->exitbranch();
  839.     };    
  840.  
  841. };
  842.  
  843. void Part::getfromXML(XMLwrapper *xml){
  844.     Penabled=xml->getparbool("enabled",Penabled);
  845.  
  846.     setPvolume(xml->getpar127("volume",Pvolume));
  847.     setPpanning(xml->getpar127("panning",Ppanning));
  848.  
  849.     Pminkey=xml->getpar127("min_key",Pminkey);
  850.     Pmaxkey=xml->getpar127("max_key",Pmaxkey);
  851.     Pkeyshift=xml->getpar127("key_shift",Pkeyshift);
  852.     Prcvchn=xml->getpar127("rcv_chn",Prcvchn);
  853.  
  854.     Pvelsns=xml->getpar127("velocity_sensing",Pvelsns);
  855.     Pveloffs=xml->getpar127("velocity_offset",Pveloffs);
  856.  
  857.     Pnoteon=xml->getparbool("note_on",Pnoteon);
  858.     Ppolymode=xml->getparbool("poly_mode",Ppolymode);
  859.     Pkeylimit=xml->getpar127("key_limit",Pkeylimit);
  860.  
  861.  
  862.     if (xml->enterbranch("INSTRUMENT")){
  863.     getfromXMLinstrument(xml);
  864.         xml->exitbranch();
  865.     };
  866.     
  867.     if (xml->enterbranch("CONTROLLER")){
  868.     ctl.getfromXML(xml);
  869.     xml->exitbranch();
  870.     };
  871.  
  872. };
  873.  
  874.  
  875.  
  876.